package P1856;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * Problema da disciplina de Estrutura de Dados e Complexidade de Algoritmos da
 * Pos Graduacao do Periodo 2011.1
 *
 * @see http://br.spoj.pl/problems/PREEMPOS/
 * @author Elenilson Vieira - 111100371 - elenilson[at]elenilsonvieira.com
 * @since 28 de maio de 2011
 */
public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        int amount = Integer.parseInt(reader.readLine().trim());

        for (int i = 0; i < amount; i++) {
            String data[] = reader.readLine().split(" ");
            int nodesAmount = Integer.parseInt(data[0]);

            char[] reassembledTree = new char[nodesAmount];
            reassembleTree(data[1].toCharArray(), data[2].toCharArray(), 0, nodesAmount - 1, reassembledTree, 0);
            printPostOrder(reassembledTree, 0);
            System.out.println("");
        }
    }

    /**
     * Remonta a arvore baseando-se nos caminhamentos pre/in ordem
     *
     * @param preOrderTraversal o caminhamento pre-ordem
     * @param inOrderTraversal o caminamento em ordem
     * @param minIndexToInOrder para a subarvore da esquerda repito o menor indice, para da direita passo o indice da raiz (de inicio passo 0)
     * @param maxIndexToInOrder para a subarvore da esquerda passo a posicao da raiz + 1, para da direita repito o maior indice (de inicio eh lenght - 1)
     * @param reassembledTree o array onde sera construida a arvore (assume-se que tem a quantidade correta de posicoes)
     * @param rootPositionInReassembledTree a posicao da raiz procurada no array da arvore reconstruida
     */
    private static void reassembleTree(char[] preOrderTraversal, char[] inOrderTraversal, int minIndexToInOrder, int maxIndexToInOrder, char[] reassembledTree, int rootPositionInReassembledTree){
        if(minIndexToInOrder > maxIndexToInOrder || rootPositionInReassembledTree >= reassembledTree.length)
            return;

        reassembledTree[rootPositionInReassembledTree] = preOrderTraversal[minIndexToInOrder];

        int rootPositionInOrder = 0;
        for (rootPositionInOrder = minIndexToInOrder; rootPositionInOrder < maxIndexToInOrder; rootPositionInOrder++) {
            if(preOrderTraversal[minIndexToInOrder] == inOrderTraversal[rootPositionInOrder])
                break;
        }

        /*** Chama para a arvore da esquerda ***/
        reassembleTree(preOrderTraversal, inOrderTraversal, minIndexToInOrder, rootPositionInOrder - 1,
                reassembledTree, (2 * (rootPositionInReassembledTree + 1) - 1));

        /*** Chama para a arvore da direita  ***/
        reassembleTree(preOrderTraversal, inOrderTraversal, rootPositionInOrder + 1, maxIndexToInOrder,
                reassembledTree, (2 * (rootPositionInReassembledTree + 1)));
    }

    /**
     * Imprime a passagem pos-ordem na mesma linha
     *
     * @param tree a arvore a ser impressa
     * @param rootIndex o indice da raiz
     */
    private static void printPostOrder(char[] tree, int rootIndex){
        int algorithmRootIndex = rootIndex + 1;
        if(rootIndex < tree.length){
            /*** Arvore esquerda ***/
            printPostOrder(tree, (2 * algorithmRootIndex) - 1);
            /*** Arvore direita ***/
            printPostOrder(tree, (2 * algorithmRootIndex));
            System.out.print(tree[rootIndex]);
        }
    }
}
